var BUNDLE_START_TIME=globalThis.nativePerformanceNow?nativePerformanceNow():Date.now(),DEV=true,process=globalThis.process||{},METRO_GLOBAL_PREFIX='',__requireCycleIgnorePatterns=[/(^|\/|\)node_modules($|\/|\)/];process.env=process.env||{};process.env.NODE_ENV=process.env.NODE_ENV||"development";
(function (global) {
'use strict';
if (DEV || !global[${__METRO_GLOBAL_PREFIX__}__d]) {
global.r = metroRequire;
global[${__METRO_GLOBAL_PREFIX__}__d] = define;
global.__c = clear;
global.__registerSegment = registerSegment;
}
var modules = clear();
const EMPTY = {};
const CYCLE_DETECTED = {};
const {
hasOwnProperty
} = {};
if (__DEV) {
global.$RefreshReg$ = global.$RefreshReg$ ?? (() => {});
global.$RefreshSig$ = global.$RefreshSig$ ?? (() => type => type);
}
function clear() {
modules = new Map();
return modules;
}
if (DEV) {
var initializingModuleIds = [];
}
function define(factory, moduleId, dependencyMap) {
if (modules.has(moduleId)) {
if (DEV) {
const inverseDependencies = arguments[4];
if (inverseDependencies) {
global.accept(moduleId, factory, dependencyMap, inverseDependencies);
}
}
return;
}
const mod = {
dependencyMap,
factory,
hasError: false,
importedAll: EMPTY,
importedDefault: EMPTY,
isInitialized: false,
publicModule: {
exports: {}
}
};
modules.set(moduleId, mod);
if (__DEV) {
mod.hot = createHotReloadingObject();
const verboseName = arguments[3];
if (verboseName) {
mod.verboseName = verboseName;
}
}
}
function metroRequire(moduleId, moduleIdHint) {
if (moduleId === null) {
if (DEV && typeof moduleIdHint === 'string') {
throw new Error("Cannot find module '" + moduleIdHint + "'");
}
throw new Error('Cannot find module');
}
if (DEV) {
const initializingIndex = initializingModuleIds.indexOf(moduleId);
if (initializingIndex !== -1) {
const cycle = initializingModuleIds.slice(initializingIndex).map(id => {
var modules_get;
return ((_modules_get = modules.get(id)) == null ? void 0 : _modules_get.verboseName) ?? '[unknown]';
});
if (shouldPrintRequireCycle(cycle)) {
cycle.push(cycle[0]);
console.warn(Require cycle: ${cycle.join(' -> ')}\n\n + 'Require cycles are allowed, but can result in uninitialized values. ' + 'Consider refactoring to remove the need for a cycle.');
}
}
}
const module = modules.get(moduleId);
return module && module.isInitialized ? module.publicModule.exports : guardedLoadModule(moduleId, module, moduleIdHint);
}
function shouldPrintRequireCycle(modules) {
const rcip = METRO_GLOBAL_PREFIX + 'requireCycleIgnorePatterns';
const regExps = globalThis[rcip] ?? global[rcip] ?? [/(^|\/|\)node_modules($|\/|\)/];
if (!Array.isArray(regExps)) {
return true;
}
const isIgnored = module => module != null && regExps.some(regExp => regExp.test(module));
return modules.every(module => !isIgnored(module));
}
function metroImportDefault(moduleId) {
var _modules_get;
if (modules.has(moduleId) && ((_modules_get = modules.get(moduleId)) == null ? void 0 : _modules_get.importedDefault) !== EMPTY) {
return modules.get(moduleId).importedDefault;
}
const exports = metroRequire(moduleId);
const importedDefault = exports && exports.__esModule ? exports.default : exports;
return modules.get(moduleId).importedDefault = importedDefault;
}
metroRequire.importDefault = metroImportDefault;
function metroImportAll(moduleId) {
var _modules_get;
if (modules.has(moduleId) && ((_modules_get = modules.get(moduleId)) == null ? void 0 : _modules_get.importedAll) !== EMPTY) {
return modules.get(moduleId).importedAll;
}
const exports = metroRequire(moduleId);
let importedAll;
if (exports && exports.__esModule) {
importedAll = exports;
} else {
importedAll = {};
if (exports) {
for (const key in exports) {
if (hasOwnProperty.call(exports, key)) {
importedAll[key] = exports[key];
}
}
}
importedAll.default = exports;
}
return modules.get(moduleId).importedAll = importedAll;
}
metroRequire[Symbol.for('expo.require')] = true;
metroRequire.importAll = metroImportAll;
metroRequire.context = function fallbackRequireContext() {
if (__DEV) {
throw new Error('The experimental Metro feature require.context is not enabled in your project.\nThis can be enabled by setting the transformer.unstable_allowRequireContext property to true in your Metro configuration.');
}
throw new Error('The experimental Metro feature require.context is not enabled in your project.');
};
metroRequire.resolveWeak = function fallbackRequireResolveWeak() {
if (DEV) {
throw new Error('require.resolveWeak cannot be called dynamically. Ensure you are using the same version of metro and metro-runtime.');
}
throw new Error('require.resolveWeak cannot be called dynamically.');
};
metroRequire.unguarded = function requireUnguarded(moduleId, moduleIdHint) {
if (DEV) {
const initializingIndex = initializingModuleIds.indexOf(moduleId);
if (initializingIndex !== -1) {
const cycle = initializingModuleIds.slice(initializingIndex).map(id => {
var _modules_get;
return ((_modules_get = modules.get(id)) == null ? void 0 : _modules_get.verboseName) ?? '[unknown]';
});
if (shouldPrintRequireCycle(cycle)) {
cycle.push(cycle[0]);
console.warn(Require cycle: ${cycle.join(' -> ')}\n\n + 'Require cycles are allowed, but can result in uninitialized values. ' + 'Consider refactoring to remove the need for a cycle.');
}
}
}
const module = modules.get(moduleId);
return module && module.isInitialized ? module.publicModule.exports : loadModuleImplementation(moduleId, module, moduleIdHint);
};
let inGuard = false;
function guardedLoadModule(moduleId, module, moduleIdHint) {
if (!inGuard && global.ErrorUtils) {
inGuard = true;
let returnValue;
try {
returnValue = loadModuleImplementation(moduleId, module, moduleIdHint);
} catch (e) {
global.ErrorUtils.reportFatalError(e);
}
inGuard = false;
return returnValue;
} else {
return loadModuleImplementation(moduleId, module, moduleIdHint);
}
}
const ID_MASK_SHIFT = 16;
const LOCAL_ID_MASK = ~0 >>> ID_MASK_SHIFT;
function unpackModuleId(moduleId) {
if (typeof moduleId !== 'number') {
throw new Error('Module ID must be a number in unpackModuleId.');
}
const segmentId = moduleId >>> ID_MASK_SHIFT;
const localId = moduleId & LOCAL_ID_MASK;
return {
segmentId,
localId
};
}
metroRequire.unpackModuleId = unpackModuleId;
function packModuleId(value) {
return (value.segmentId << ID_MASK_SHIFT) + value.localId;
}
metroRequire.packModuleId = packModuleId;
const moduleDefinersBySegmentID = [];
const definingSegmentByModuleID = new Map();
function registerSegment(segmentId, moduleDefiner, moduleIds) {
moduleDefinersBySegmentID[segmentId] = moduleDefiner;
if (DEV) {
if (segmentId === 0 && moduleIds) {
throw new Error('registerSegment: Expected moduleIds to be null for main segment');
}
if (segmentId !== 0 && !moduleIds) {
throw new Error('registerSegment: Expected moduleIds to be passed for segment #' + segmentId);
}
}
if (moduleIds) {
moduleIds.forEach(moduleId => {
if (!modules.has(moduleId) && !definingSegmentByModuleID.has(moduleId)) {
definingSegmentByModuleID.set(moduleId, segmentId);
}
});
}
}
function loadModuleImplementation(moduleId, module, moduleIdHint) {
if (!module && moduleDefinersBySegmentID.length > 0) {
const segmentId = definingSegmentByModuleID.get(moduleId) ?? 0;
const definer = moduleDefinersBySegmentID[segmentId];
if (definer != null) {
definer(moduleId);
module = modules.get(moduleId);
definingSegmentByModuleID.delete(moduleId);
}
}
if (!module) {
throw unknownModuleError(moduleId, moduleIdHint);
}
if (module.hasError) {
throw module.error;
}
if (DEV) {
var Systrace = requireSystrace();
var Refresh = requireRefresh();
}
module.isInitialized = true;
const {
factory,
dependencyMap
} = module;
if (DEV) {
initializingModuleIds.push(moduleId);
}
try {
if (DEV) {
Systrace.beginEvent('JS_require' + (module.verboseName || moduleId));
}
const moduleObject = module.publicModule;
if (DEV) {
moduleObject.hot = module.hot;
var prevRefreshReg = global.$RefreshReg$;
var prevRefreshSig = global.$RefreshSig$;
if (Refresh != null) {
const RefreshRuntime = Refresh;
global.$RefreshReg$ = (type, id) => {
const prefixedModuleId = METRO_GLOBAL_PREFIX + ' ' + moduleId + ' ' + id;
RefreshRuntime.register(type, prefixedModuleId);
};
global.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
}
}
moduleObject.id = moduleId;
factory == null ? void 0 : factory(global, metroRequire, metroImportDefault, metroImportAll, moduleObject, moduleObject.exports, dependencyMap);
if (!DEV) {
module.factory = undefined;
module.dependencyMap = undefined;
}
if (DEV) {
Systrace.endEvent();
if (Refresh != null) {
const prefixedModuleId = METRO_GLOBAL_PREFIX + ' ' + moduleId;
registerExportsForReactRefresh(Refresh, moduleObject.exports, prefixedModuleId);
}
}
return moduleObject.exports;
} catch (e) {
module.hasError = true;
module.error = e;
module.isInitialized = false;
module.publicModule.exports = undefined;
throw e;
} finally {
if (DEV) {
if (initializingModuleIds.pop() !== moduleId) {
throw new Error('initializingModuleIds is corrupt; something is terribly wrong');
}
global.$RefreshReg$ = prevRefreshReg;
global.$RefreshSig$ = prevRefreshSig;
}
}
}
function unknownModuleError(id, moduleIdHint) {
let message = 'Requiring unknown module "' + (id ?? moduleIdHint ?? [unknown optional import]) + '".';
if (DEV) {
message += ' If you are sure the module exists, try restarting Metro. ' + 'You may also want to run yarn or npm install.';
}
return Error(message);
}
if (DEV) {
metroRequire.Systrace = {
beginEvent: () => {},
endEvent: () => {}
};
metroRequire.getModules = () => {
return modules;
};
var createHotReloadingObject = function () {
const hot = {
_acceptCallback: null,
_disposeCallback: null,
_didAccept: false,
accept: callback => {
hot._didAccept = true;
hot._acceptCallback = callback;
},
dispose: callback => {
hot._disposeCallback = callback;
}
};
return hot;
};
let reactRefreshTimeout = null;
const metroHotUpdateModule = function (id, factory, dependencyMap, inverseDependencies) {
const mod = modules.get(id);
if (!mod) {
if (factory) {
return;
}
throw unknownModuleError(id);
}
if (!mod.hasError && !mod.isInitialized) {
mod.factory = factory;
mod.dependencyMap = dependencyMap;
return;
}
const Refresh = requireRefresh();
const refreshBoundaryIDs = new Set();
let didBailOut = false;
let updatedModuleIDs;
try {
updatedModuleIDs = topologicalSort([id], pendingID => {
const pendingModule = modules.get(pendingID);
if (pendingModule == null) {
return [];
}
const pendingHot = pendingModule.hot;
if (pendingHot == null) {
throw new Error('[Refresh] Expected module.hot to always exist in DEV.');
}
let canAccept = pendingHot._didAccept;
if (!canAccept && Refresh != null) {
const isBoundary = isReactRefreshBoundary(Refresh, pendingModule.publicModule.exports);
if (isBoundary) {
canAccept = true;
refreshBoundaryIDs.add(pendingID);
}
}
if (canAccept) {
return [];
}
const parentIDs = inverseDependencies[pendingID];
if (parentIDs.length === 0) {
performFullRefresh('No root boundary', {
source: mod,
failed: pendingModule
});
didBailOut = true;
return [];
}
return parentIDs;
}, () => didBailOut).reverse();
} catch (e) {
if (e === CYCLE_DETECTED) {
performFullRefresh('Dependency cycle', {
source: mod
});
return;
}
throw e;
}
if (didBailOut) {
return;
}
const seenModuleIDs = new Set();
for (let i = 0; i < updatedModuleIDs.length; i++) {
const updatedID = updatedModuleIDs[i];
if (seenModuleIDs.has(updatedID)) {
continue;
}
seenModuleIDs.add(updatedID);
const updatedMod = modules.get(updatedID);
if (updatedMod == null) {
throw new Error('[Refresh] Expected to find the updated module.');
}
const prevExports = updatedMod.publicModule.exports;
const didError = runUpdatedModule(updatedID, updatedID === id ? factory : undefined, updatedID === id ? dependencyMap : undefined);
const nextExports = updatedMod.publicModule.exports;
if (didError) {
return;
}
if (refreshBoundaryIDs.has(updatedID)) {
const isNoLongerABoundary = !isReactRefreshBoundary(Refresh, nextExports);
const didInvalidate = shouldInvalidateReactRefreshBoundary(Refresh, prevExports, nextExports);
if (isNoLongerABoundary || didInvalidate) {
const parentIDs = inverseDependencies[updatedID];
if (parentIDs.length === 0) {
performFullRefresh(isNoLongerABoundary ? 'No longer a boundary' : 'Invalidated boundary', {
source: mod,
failed: updatedMod
});
return;
}
for (let j = 0; j < parentIDs.length; j++) {
const parentID = parentIDs[j];
const parentMod = modules.get(parentID);
if (parentMod == null) {
throw new Error('[Refresh] Expected to find parent module.');
}
const canAcceptParent = isReactRefreshBoundary(Refresh, parentMod.publicModule.exports);
if (canAcceptParent) {
refreshBoundaryIDs.add(parentID);
updatedModuleIDs.push(parentID);
} else {
performFullRefresh('Invalidated boundary', {
source: mod,
failed: parentMod
});
return;
}
}
}
}
}
if (Refresh != null) {
if (reactRefreshTimeout == null) {
reactRefreshTimeout = setTimeout(() => {
reactRefreshTimeout = null;
Refresh.performReactRefresh();
}, 30);
}
}
};
const topologicalSort = function (roots, getEdges, earlyStop) {
const result = [];
const visited = new Set();
const stack = new Set();
function traverseDependentNodes(node) {
if (stack.has(node)) {
throw CYCLE_DETECTED;
}
if (visited.has(node)) {
return;
}
visited.add(node);
stack.add(node);
const dependentNodes = getEdges(node);
if (earlyStop(node)) {
stack.delete(node);
return;
}
dependentNodes.forEach(dependent => {
traverseDependentNodes(dependent);
});
stack.delete(node);
result.push(node);
}
roots.forEach(root => {
traverseDependentNodes(root);
});
return result;
};
const runUpdatedModule = function (id, factory, dependencyMap) {
const mod = modules.get(id);
if (mod == null) {
throw new Error('[Refresh] Expected to find the module.');
}
const {
hot
} = mod;
if (!hot) {
throw new Error('[Refresh] Expected module.hot to always exist in DEV.');
}
if (hot._disposeCallback) {
try {
hot._disposeCallback();
} catch (error) {
console.error(Error while calling dispose handler for module ${id}:, error);
}
}
if (factory) {
mod.factory = factory;
}
if (dependencyMap) {
mod.dependencyMap = dependencyMap;
}
mod.hasError = false;
mod.error = undefined;
mod.importedAll = EMPTY;
mod.importedDefault = EMPTY;
mod.isInitialized = false;
const prevExports = mod.publicModule.exports;
mod.publicModule.exports = {};
hot._didAccept = false;
hot._acceptCallback = null;
hot._disposeCallback = null;
metroRequire(id);
if (mod.hasError) {
mod.hasError = false;
mod.isInitialized = true;
mod.error = null;
mod.publicModule.exports = prevExports;
return true;
}
if (hot._acceptCallback) {
try {
hot._acceptCallback();
} catch (error) {
console.error(Error while calling accept handler for module ${id}:, error);
}
}
return false;
};
const performFullRefresh = (reason, modules) => {
if (typeof window !== 'undefined' && window.location != null && typeof window.location.reload === 'function') {
window.location.reload();
} else {
const Refresh = requireRefresh();
if (Refresh != null) {
var _modules_source, _modules_failed;
const sourceName = ((_modules_source = modules.source) == null ? void 0 : _modules_source.verboseName) ?? 'unknown';
const failedName = ((_modules_failed = modules.failed) == null ? void 0 : _modules_failed.verboseName) ?? 'unknown';
Refresh.performFullRefresh(Fast Refresh - ${reason} <${sourceName}> <${failedName}>);
} else {
console.warn('Could not reload the application after an edit.');
}
}
};
var isSpecifierSafeToCheck = (moduleExports, key) => {
if (moduleExports && moduleExports.esModule) {
return true;
} else {
const desc = Object.getOwnPropertyDescriptor(moduleExports, key);
return !desc || !desc.get;
}
};
var isReactRefreshBoundary = function (Refresh, moduleExports) {
if (Refresh.isLikelyComponentType(moduleExports)) {
return true;
}
if (moduleExports == null || typeof moduleExports !== 'object') {
return false;
}
let hasExports = false;
let areAllExportsComponents = true;
for (const key in moduleExports) {
hasExports = true;
if (key === '__esModule') {
continue;
} else if (!isSpecifierSafeToCheck(moduleExports, key)) {
return false;
}
const exportValue = moduleExports[key];
if (!Refresh.isLikelyComponentType(exportValue)) {
areAllExportsComponents = false;
}
}
return hasExports && areAllExportsComponents;
};
var shouldInvalidateReactRefreshBoundary = (Refresh, prevExports, nextExports) => {
const prevSignature = getRefreshBoundarySignature(Refresh, prevExports);
const nextSignature = getRefreshBoundarySignature(Refresh, nextExports);
if (prevSignature.length !== nextSignature.length) {
return true;
}
for (let i = 0; i < nextSignature.length; i++) {
if (prevSignature[i] !== nextSignature[i]) {
return true;
}
}
return false;
};
var getRefreshBoundarySignature = (Refresh, moduleExports) => {
const signature = [];
signature.push(Refresh.getFamilyByType(moduleExports));
if (moduleExports == null || typeof moduleExports !== 'object') {
return signature;
}
for (const key in moduleExports) {
if (key === '__esModule') {
continue;
} else if (!isSpecifierSafeToCheck(moduleExports, key)) {
continue;
}
const exportValue = moduleExports[key];
signature.push(key);
signature.push(Refresh.getFamilyByType(exportValue));
}
return signature;
};
var registerExportsForReactRefresh = (Refresh, moduleExports, moduleID) => {
Refresh.register(moduleExports, moduleID + ' %exports%');
if (moduleExports == null || typeof moduleExports !== 'object') {
return;
}
for (const key in moduleExports) {
if (!isSpecifierSafeToCheck(moduleExports, key)) {
continue;
}
const exportValue = moduleExports[key];
const typeID = moduleID + ' %exports% ' + key;
Refresh.register(exportValue, typeID);
}
};
global.__accept = metroHotUpdateModule;
}
if (__DEV) {
var requireSystrace = function requireSystrace() {
return global[METRO_GLOBAL_PREFIX + 'SYSTRACE'] || metroRequire.Systrace;
};
var requireRefresh = function requireRefresh() {
return global[__METRO_GLOBAL_PREFIX + 'ReactRefresh'] || global[global.__METRO_GLOBAL_PREFIX + '__ReactRefresh'] || metroRequire.Refresh;
};
}
})(typeof globalThis !== 'undefined' ? globalThis : typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);
(function (global) {
global.$$require_external = typeof require !== "undefined" ? require : () => null;
})(typeof globalThis !== 'undefined' ? globalThis : typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);
/ HMR env vars from Expo CLI (dev-only) / process.env=Object.defineProperties(process.env, {"EXPO_PUBLIC_PROJECT_ROOT": { enumerable: true, value: "C:\Users\ravic\development\karmyq\apps\mobile" }});
(function (global) {
/*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*
* @format
*
* @nolint
* @polyfill
/
'use client';
/ eslint-disable no-shadow, eqeqeq, no-unused-vars, no-control-regex /
/*
* This pipes all of our console logging functions to native logging so that
* JavaScript errors in required modules show up in Xcode via NSLog.
/
const inspect = function () {
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
//
// https://github.com/joyent/node/blob/master/lib/util.js
function inspect(obj, opts) {
var ctx = {
seen: [],
formatValueCalls: 0,
stylize: stylizeNoColor
};
return formatValue(ctx, obj, opts.depth);
}
function stylizeNoColor(str, styleType) {
return str;
}
function arrayToHash(array) {
var hash = {};
array.forEach(function (val, idx) {
hash[val] = true;
});
return hash;
}
function formatValue(ctx, value, recurseTimes) {
ctx.formatValueCalls++;
if (ctx.formatValueCalls > 200) {
return `[TOO BIG formatValueCalls ${ctx.formatValueCalls} exceeded limit of 200]`;
}
// Primitive types cannot have properties
var primitive = formatPrimitive(ctx, value);
if (primitive) {
return primitive;
}
// Look up the keys of the object.
var keys = Object.keys(value);
var visibleKeys = arrayToHash(keys);
// IE doesn't make error fields non-enumerable
// http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
if (isError(value) && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
return formatError(value);
}
// Some type of object without properties can be shortcutted.
if (keys.length === 0) {
if (isFunction(value)) {
var name = value.name ? ': ' + value.name : '';
return ctx.stylize('[Function' + name + ']', 'special');
}
if (isRegExp(value)) {
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
}
if (isDate(value)) {
return ctx.stylize(Date.prototype.toString.call(value), 'date');
}
if (isError(value)) {
return formatError(value);
}
}
var base = '',
array = false,
braces = ['{', '}'];
// Make Array say that they are Array
if (isArray(value)) {
array = true;
braces = ['[', ']'];
}
// Make functions say that they are functions
if (isFunction(value)) {
var n = value.name ? ': ' + value.name : '';
base = ' [Function' + n + ']';
}
// Make RegExps say that they are RegExps
if (isRegExp(value)) {
base = ' ' + RegExp.prototype.toString.call(value);
}
// Make dates with properties first say the date
if (isDate(value)) {
base = ' ' + Date.prototype.toUTCString.call(value);
}
// Make error with message first say the error
if (isError(value)) {
base = ' ' + formatError(value);
}
if (keys.length === 0 && (!array || value.length == 0)) {
return braces[0] + base + braces[1];
}
if (recurseTimes < 0) {
if (isRegExp(value)) {
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
} else {
return ctx.stylize('[Object]', 'special');
}
}
ctx.seen.push(value);
var output;
if (array) {
output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
} else {
output = keys.map(function (key) {
return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
});
}
ctx.seen.pop();
return reduceToSingleString(output, base, braces);
}
function formatPrimitive(ctx, value) {
if (isUndefined(value)) return ctx.stylize('undefined', 'undefined');
if (isString(value)) {
var simple = "'" + JSON.stringify(value).replace(/^"|"$/g, '').replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
return ctx.stylize(simple, 'string');
}
if (isNumber(value)) return ctx.stylize('' + value, 'number');
if (isBoolean(value)) return ctx.stylize('' + value, 'boolean');
// For some reason typeof null is "object", so special case here.
if (isNull(value)) return ctx.stylize('null', 'null');
}
function formatError(value) {
return '[' + Error.prototype.toString.call(value) + ']';
}
function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
var output = [];
for (var i = 0, l = value.length; i < l; ++i) {
if (hasOwnProperty(value, String(i))) {
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));
} else {
output.push('');
}
}
keys.forEach(function (key) {
if (!key.match(/^\d+$/)) {
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));
}
});
return output;
}
function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
var name, str, desc;
desc = Object.getOwnPropertyDescriptor(value, key) || {
value: value[key]
};
if (desc.get) {
if (desc.set) {
str = ctx.stylize('[Getter/Setter]', 'special');
} else {
str = ctx.stylize('[Getter]', 'special');
}
} else {
if (desc.set) {
str = ctx.stylize('[Setter]', 'special');
}
}
if (!hasOwnProperty(visibleKeys, key)) {
name = '[' + key + ']';
}
if (!str) {
if (ctx.seen.indexOf(desc.value) < 0) {
if (isNull(recurseTimes)) {
str = formatValue(ctx, desc.value, null);
} else {
str = formatValue(ctx, desc.value, recurseTimes - 1);
}
if (str.indexOf('\n') > -1) {
if (array) {
str = str.split('\n').map(function (line) {
return ' ' + line;
}).join('\n').slice(2);
} else {
str = '\n' + str.split('\n').map(function (line) {
return ' ' + line;
}).join('\n');
}
}
} else {
str = ctx.stylize('[Circular]', 'special');
}
}
if (isUndefined(name)) {
if (array && key.match(/^\d+$/)) {
return str;
}
name = JSON.stringify('' + key);
if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
name = name.slice(1, name.length - 1);
name = ctx.stylize(name, 'name');
} else {
name = name.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
name = ctx.stylize(name, 'string');
}
}
return name + ': ' + str;
}
function reduceToSingleString(output, base, braces) {
var numLinesEst = 0;
var length = output.reduce(function (prev, cur) {
numLinesEst++;
if (cur.indexOf('\n') >= 0) numLinesEst++;
return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
}, 0);
if (length > 60) {
return braces[0] + (base === '' ? '' : base + '\n ') + ' ' + output.join(',\n ') + ' ' + braces[1];
}
return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
}
// NOTE: These type checking functions intentionally don't use `instanceof`
// because it is fragile and can be easily faked with `Object.create()`.
function isArray(ar) {
return Array.isArray(ar);
}
function isBoolean(arg) {
return typeof arg === 'boolean';
}
function isNull(arg) {
return arg === null;
}
function isNullOrUndefined(arg) {
return arg == null;
}
function isNumber(arg) {
return typeof arg === 'number';
}
function isString(arg) {
return typeof arg === 'string';
}
function isSymbol(arg) {
return typeof arg === 'symbol';
}
function isUndefined(arg) {
return arg === void 0;
}
function isRegExp(re) {
return isObject(re) && objectToString(re) === '[object RegExp]';
}
function isObject(arg) {
return typeof arg === 'object' && arg !== null;
}
function isDate(d) {
return isObject(d) && objectToString(d) === '[object Date]';
}
function isError(e) {
return isObject(e) && (objectToString(e) === '[object Error]' || e instanceof Error);
}
function isFunction(arg) {
return typeof arg === 'function';
}
function objectToString(o) {
return Object.prototype.toString.call(o);
}
function hasOwnProperty(obj, prop) {
return Object.prototype.hasOwnProperty.call(obj, prop);
}
return inspect;
}();
const INDEX_COLUMN_NAME = '(index)';
const LOG_LEVELS = {
trace: 0,
info: 1,
warn: 2,
error: 3
};
function getNativeLogFunction(level) {
return function () {
let str;
if (arguments.length === 1 && typeof arguments[0] === 'string') {
str = arguments[0];
} else {
str = Array.prototype.map.call(arguments, function (arg) {
return inspect(arg, {
depth: 10
});
}).join(', ');
}
// TRICKY
// If more than one argument is provided, the code above collapses them all
// into a single formatted string. This transform wraps string arguments in
// single quotes (e.g. "foo" -> "'foo'") which then breaks the "Warning:"
// check below. So it's important that we look at the first argument, rather
// than the formatted argument string.
const firstArg = arguments[0];
let logLevel = level;
if (typeof firstArg === 'string' && firstArg.slice(0, 9) === 'Warning: ' && logLevel >= LOG_LEVELS.error) {
// React warnings use console.error so that a stack trace is shown,
// but we don't (currently) want these to show a redbox
// (Note: Logic duplicated in ExceptionsManager.js.)
logLevel = LOG_LEVELS.warn;
}
if (groupStack.length) {
str = groupFormat('', str);
}
global.nativeLoggingHook(str, logLevel);
};
}
function repeat(element, n) {
return Array.apply(null, Array(n)).map(function () {
return element;
});
}
function formatCellValue(cell, key) {
if (key === INDEX_COLUMN_NAME) {
return cell[key];
}
if (cell.hasOwnProperty(key)) {
var cellValue = cell[key];
switch (typeof cellValue) {
case 'function':
return 'ƒ';
case 'string':
return "'" + cellValue + "'";
case 'object':
return cellValue == null ? 'null' : '{…}';
}
return String(cellValue);
}
return '';
}
function consoleTablePolyfill(data, columns) {
var rows;
// convert object -> array
if (Array.isArray(data)) {
rows = data.map((row, index) => {
var processedRow = {};
processedRow[INDEX_COLUMN_NAME] = String(index);
Object.assign(processedRow, row);
return processedRow;
});
} else {
rows = [];
for (var key in data) {
if (data.hasOwnProperty(key)) {
var processedRow = {};
processedRow[INDEX_COLUMN_NAME] = key;
Object.assign(processedRow, data[key]);
rows.push(processedRow);
}
}
}
if (rows.length === 0) {
global.nativeLoggingHook('', LOG_LEVELS.info);
return;
}
if (Array.isArray(columns)) {
columns = [INDEX_COLUMN_NAME].concat(columns);
} else {
columns = Array.from(rows.reduce((columnSet, row) => {
Object.keys(row).forEach(key => columnSet.add(key));
return columnSet;
}, new Set()));
}
var stringRows = [];
var columnWidths = [];
// Convert each cell to a string. Also
// figure out max cell width for each column
columns.forEach(function (k, i) {
columnWidths[i] = k.length;
for (var j = 0; j < rows.length; j++) {
var cellStr = formatCellValue(rows[j], k);
stringRows[j] = stringRows[j] || [];
stringRows[j][i] = cellStr;
columnWidths[i] = Math.max(columnWidths[i], cellStr.length);
}
});
// Join all elements in the row into a single string with | separators
// (appends extra spaces to each cell to make separators | aligned)
function joinRow(row, space) {
var cells = row.map(function (cell, i) {
var extraSpaces = repeat(' ', columnWidths[i] - cell.length).join('');
return cell + extraSpaces;
});
space = space || ' ';
return '| ' + cells.join(space + '|' + space) + ' |';
}
var separators = columnWidths.map(function (columnWidth) {
return repeat('-', columnWidth).join('');
});
var separatorRow = joinRow(separators);
var header = joinRow(columns);
var table = [header, separatorRow];
for (var i = 0; i < rows.length; i++) {
table.push(joinRow(stringRows[i]));
}
// Notice extra empty line at the beginning.
// Native logging hook adds "RCTLog >" at the front of every
// logged string, which would shift the header and screw up
// the table
global.nativeLoggingHook('\n' + table.join('\n'), LOG_LEVELS.info);
}
const GROUP_PAD = '\u2502'; // Box light vertical
const GROUP_OPEN = '\u2510'; // Box light down+left
const GROUP_CLOSE = '\u2518'; // Box light up+left
const groupStack = [];
function groupFormat(prefix, msg) {
// Insert group formatting before the console message
return groupStack.join('') + prefix + ' ' + (msg || '');
}
function consoleGroupPolyfill(label) {
global.nativeLoggingHook(groupFormat(GROUP_OPEN, label), LOG_LEVELS.info);
groupStack.push(GROUP_PAD);
}
function consoleGroupCollapsedPolyfill(label) {
global.nativeLoggingHook(groupFormat(GROUP_CLOSE, label), LOG_LEVELS.info);
groupStack.push(GROUP_PAD);
}
function consoleGroupEndPolyfill() {
groupStack.pop();
global.nativeLoggingHook(groupFormat(GROUP_CLOSE), LOG_LEVELS.info);
}
function consoleAssertPolyfill(expression, label) {
if (!expression) {
global.nativeLoggingHook('Assertion failed: ' + label, LOG_LEVELS.error);
}
}
// https://developer.mozilla.org/en-US/docs/Web/API/console/timeStamp_static.
// Non-standard API for recording markers on a timeline of the Performance instrumentation.
// The actual logging is not provided by definition.
function consoleTimeStampPolyfill() {}
if (global.nativeLoggingHook) {
const originalConsole = global.console;
// Preserve the original console as originalConsole
if (DEV && originalConsole) {
const descriptor = Object.getOwnPropertyDescriptor(global, 'console');
if (descriptor) {
Object.defineProperty(global, 'originalConsole', descriptor);
}
}
global.console = Object.assign({
timeStamp: consoleTimeStampPolyfill
}, originalConsole ?? {}, {
error: getNativeLogFunction(LOG_LEVELS.error),
info: getNativeLogFunction(LOG_LEVELS.info),
log: getNativeLogFunction(LOG_LEVELS.info),
warn: getNativeLogFunction(LOG_LEVELS.warn),
trace: getNativeLogFunction(LOG_LEVELS.trace),
debug: getNativeLogFunction(LOG_LEVELS.trace),
table: consoleTablePolyfill,
group: consoleGroupPolyfill,
groupEnd: consoleGroupEndPolyfill,
groupCollapsed: consoleGroupCollapsedPolyfill,
assert: consoleAssertPolyfill
});
// TODO(T206796580): This was copy-pasted from ExceptionsManager.js
// Delete the copy there after the c++ pipeline is rolled out everywhere.
if (global.RN$useAlwaysAvailableJSErrorHandling === true) {
let originalConsoleError = console.error;
console.reportErrorsAsExceptions = true;
function stringifySafe(arg) {
return inspect(arg, {
depth: 10
}).replace(/\n\s*/g, ' ');
}
console.error = function (...args) {
originalConsoleError.apply(this, args);
if (!console.reportErrorsAsExceptions) {
return;
}
if (global.RN$inExceptionHandler?.()) {
return;
}
let error;
const firstArg = args[0];
if (firstArg?.stack) {
// RN$handleException will console.error this with high enough fidelity.
error = firstArg;
} else {
if (typeof firstArg === 'string' && firstArg.startsWith('Warning: ')) {
// React warnings use console.error so that a stack trace is shown, but
// we don't (currently) want these to show a redbox
return;
}
const message = args.map(arg => typeof arg === 'string' ? arg : stringifySafe(arg)).join(' ');
error = new Error(message);
error.name = 'console.error';
}
const isFatal = false;
const reportToConsole = false;
global.RN$handleException(error, isFatal, reportToConsole);
};
}
Object.defineProperty(console, '_isPolyfilled', {
value: true,
enumerable: false
});
// If available, also call the original `console` method since that is
// sometimes useful. Ex: on OS X, this will let you see rich output in
// the Safari Web Inspector console.
if (__DEV__ && originalConsole) {
Object.keys(console).forEach(methodName => {
const reactNativeMethod = console[methodName];
if (originalConsole[methodName] && reactNativeMethod !== originalConsole[methodName]) {
console[methodName] = function () {
originalConsole[methodName](...arguments);
reactNativeMethod.apply(console, arguments);
};
}
});
// The following methods are not supported by this polyfill but
// we still should pass them to original console if they are
// supported by it.
['clear', 'dir', 'dirxml', 'profile', 'profileEnd'].forEach(methodName => {
if (typeof originalConsole[methodName] === 'function') {
console[methodName] = function () {
originalConsole[methodName](...arguments);
};
}
});
}
} else if (!global.console) {
function stub() {}
const log = global.print || stub;
global.console = {
debug: log,
error: log,
info: log,
log: log,
trace: log,
warn: log,
assert(expression, label) {
if (!expression) {
log('Assertion failed: ' + label);
}
},
clear: stub,
dir: stub,
dirxml: stub,
group: stub,
groupCollapsed: stub,
groupEnd: stub,
profile: stub,
profileEnd: stub,
table: stub,
timeStamp: stub
};
Object.defineProperty(console, 'isPolyfilled', {
value: true,
enumerable: false
});
}
})(typeof globalThis !== 'undefined' ? globalThis : typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);
(function (global) {
let _inGuard = 0;
let _globalHandler = global.RN$useAlwaysAvailableJSErrorHandling === true ? global.RN$handleException : (e, isFatal) => {
throw e;
};
const ErrorUtils = {
setGlobalHandler(fun) {
_globalHandler = fun;
},
getGlobalHandler() {
return _globalHandler;
},
reportError(error) {
_globalHandler && _globalHandler(error, false);
},
reportFatalError(error) {
_globalHandler && _globalHandler(error, true);
},
applyWithGuard(fun, context, args, unused_onError, unused_name) {
try {
_inGuard++;
return fun.apply(context, args);
} catch (e) {
ErrorUtils.reportError(e);
} finally {
_inGuard--;
}
return null;
},
applyWithGuardIfNeeded(fun, context, args) {
if (ErrorUtils.inGuard()) {
return fun.apply(context, args);
} else {
ErrorUtils.applyWithGuard(fun, context, args);
}
return null;
},
inGuard() {
return !!_inGuard;
},
guard(fun, name, context) {
if (typeof fun !== 'function') {
console.warn('A function must be passed to ErrorUtils.guard, got ', fun);
return null;
}
const guardName = name ?? fun.name ?? '';
function guarded(...args) {
return ErrorUtils.applyWithGuard(fun, context ?? this, args, null, guardName);
}
return guarded;
}
};
global.ErrorUtils = ErrorUtils;
})(typeof globalThis !== 'undefined' ? globalThis : typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);
__d(function (global, require, $$IMPORT_DEFAULT, $$_IMPORT_ALL, module, exports, _dependencyMap) {
"use strict";
require(dependencyMap[0], "expo-router/entry-classic");
},0,[1],"../../node_modules/expo-router/entry.js");
__d(function (global, require, $$IMPORT_DEFAULT, $$_IMPORT_ALL, module, exports, _dependencyMap) {
"use strict";
require(_dependencyMap[0], "@expo/metro-runtime");
var _expoRouterBuildQualifiedEntry = require(_dependencyMap[1], "expo-router/build/qualified-entry");
var _expoRouterBuildRenderRootComponent = require(_dependencyMap[2], "expo-router/build/renderRootComponent");
// @expo/metro-runtime MUST be the first import to ensure Fast Refresh works
// on web.
// This file should only import and register the root. No components or exports
// should be added here.
(0, expoRouterBuildRenderRootComponent.renderRootComponent)(_expoRouterBuildQualifiedEntry.App);
},1,[2,241,1164],"../../node_modules/expo-router/entry-classic.js");
__d(function (global, require, $$IMPORT_DEFAULT, $$_IMPORT_ALL, module, exports, _dependencyMap) {
"use strict";
require(_dependencyMap[0], "./location/install");
require(_dependencyMap[1], "@expo/metro-runtime/rsc/runtime");
/*
* Copyright © 2023 650 Industries.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
/
if (DEV) {
require(_dependencyMap[2], "./metroServerLogs").captureStackForServerLogs();
// TODO: Remove when fixed upstream. Expected in RN 0.82.
// https://github.com/facebook/react-native/commit/c4082c9ce208a324c2d011823ca2ba432411aafc
require(_dependencyMap[3], "./promiseRejectionTracking").enablePromiseRejectionTracking();
// @ts-expect-error: TODO: Remove this when we remove the log box.
globalThis.__expo_dev_resetErrors = require(_dependencyMap[4], "./error-overlay/LogBox").default.clearAllLogs;
}
},2,[3,4,5,6,7],"../../node_modules/@expo/metro-runtime/src/index.ts");
__d(function (global, require, $$_IMPORT_DEFAULT, $$IMPORT_ALL, module, exports, _dependencyMap) {},3,[],"../../node_modules/@expo/metro-runtime/src/location/install.ts");
__d(function (global, require, $$IMPORT_DEFAULT, $$_IMPORT_ALL, module, exports, _dependencyMap) {
/*
* Copyright © 2024 650 Industries.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
/
// React Native's error handling is full of bugs which cause the app to crash in production.
// We'll disable their handling in production native builds to ensure missing modules are shown to the user.
const disableReactNativeMissingModuleHandling = !DEV && (false || typeof window === 'undefined');
globalThis.webpack_chunk_load = id => {
return global${__METRO_GLOBAL_PREFIX__}__loadBundleAsync;
};
globalThis.webpack_require = id => {
// This logic can be tested by running a production iOS build without virtual client boundaries. This will result in all split chunks being missing and
// errors being thrown on RSC load.
const original = ErrorUtils.reportFatalError;
if (disableReactNativeMissingModuleHandling) {
ErrorUtils.reportFatalError = err => {
// Throw the error so the __r function exits as expected. The error will then be caught by the nearest error boundary.
throw err;
};
}
try {
return global[`${__METRO_GLOBAL_PREFIX__}__r`](id);
} finally {
// Restore the original error handling.
if (disableReactNativeMissingModuleHandling) {
ErrorUtils.reportFatalError = original;
}
}
};
},4,[],"../../node_modules/@expo/metro-runtime/rsc/runtime.js");
__d(function (global, require, $$_IMPORT_DEFAULT, $$_IMPORT_ALL, module, exports, _dependencyMap) {
"use strict";
Object.defineProperty(exports, '__esModule', {
value: true
});
exports.captureStackForServerLogs = captureStackForServerLogs;
function captureStackForServerLogs() {}
},5,[],"../../node_modules/@expo/metro-runtime/src/metroServerLogs.ts");
__d(function (global, require, $$_IMPORT_DEFAULT, $$_IMPORT_ALL, module, exports, _dependencyMap) {
"use strict";
Object.defineProperty(exports, '__esModule', {
value: true
});
exports.enablePromiseRejectionTracking = enablePromiseRejectionTracking;
// NOTE(@krystofwoldrich): This is only needed for native runtimes (hermes)
function enablePromiseRejectionTracking() {}
},6,[],"../../node_modules/@expo/metro-runtime/src/promiseRejectionTracking.ts");
__d(function (global, require, $$_IMPORT_DEFAULT, $$_IMPORT_ALL, module, exports, _dependencyMap) {
"use strict";
Object.defineProperty(exports, '__esModule', {
value: true
});
Object.defineProperty(exports, "default", {
enumerable: true,
get: function () {
return _default;
}
});
Object.defineProperty(exports, "LogData", {
enumerable: true,
get: function () {
return _DataLogBoxData.LogData;
}
[Message truncated - exceeded 50,000 character limit]